19. Central Limit Theorem

Number of Outcomes¶

We have already seen coin flips, and how they relate to Pascal's triangle, how they evolve in to binomial distribution earlier in Problem Set 2 - Probability section.

In 19A. Central Limit Theorem section, Sebastian ups the game with tossing a die with 3 outcomes (1,2,3). While we could follow pattern to calculate results, visualizing how that outcomes would be could be helpful to strengthen our insights. So I have created another set of functions that could help us do that.

In [1]:

# just a helper function for easier youtube call
def strip_url(url):
    return url.replace('https://youtu.be/','')

from IPython.display import YouTubeVideo
url = 'https://youtu.be/jajxhNBnbmI'
YouTubeVideo(strip_url(url))

Out[1]:

What is the largest sum of outcomes possible?

In given problem (die toss resulting in 0 or 1 or 2), the maximum possible outcome is 2.
If we toss 4 times, each time maximum possibility is 2, so, the largest sum we could get out of all sequences is $4 \times 2 = 8$

Counting Outcomes 5¶

In [2]:

url = 'https://youtu.be/4d6upzsvBTk'
YouTubeVideo(strip_url(url))

Out[2]:

In [4]:

from graphviz import Digraph
from anyflipviz import draw_graph

# define our problem
n_outcomes = 3  # 0,1,2
n_flips = 1     # as per current problem in above video

g = Digraph(strict=True)
g = draw_graph(g, n_outcomes, n_flips)
g

Out[4]:

As can be seen above, for just 1 flip, sum is just the outcome as there is nothing more to add. So X=0 sum 0 occurs 1 time, sum 1 occurs 1 time, and sum 2 occurs 1 time.

$ \text {Let X denote the sum of sequence. Then after 1 toss} \\ X = 0, \ n(X) = 1 \\ X = 1, \ n(X) = 1 \\ X = 2, \ n(X) = 1 $

Counting Outcomes 6¶

The tricky part starts here..

In [5]:

url = 'https://youtu.be/QUw97os4gAc'
YouTubeVideo(strip_url(url))

Out[5]:

Instead of following pattern established earlier and used by Sebastian above, let us visualize the problem in its entirety.

In [6]:

# define our problem
n_outcomes = 3  # 0,1,2
n_flips = 2     # as per current problem in above video

g = Digraph(strict=True)
g = draw_graph(g, n_outcomes, n_flips)
g

Out[6]:

Now each seqeunce will have 2 digits. For eg, take left most branch in above tree. Its 00. So sum is 0. And then we have 01, Sum = 1 and so on. Let us also tabulate these sequences for your better understanding. Along the way, I also note the sequence's sum X.

In [8]:

import pandas as pd 
from anyflipviz import get_combinations

temp_df = get_combinations(n_outcomes, n_flips)
temp_df

Out[8]:

	sequence	x
0	00	0
1	01	1
2	02	2
3	10	1
4	11	2
5	12	3
6	20	2
7	21	3
8	22	4

Let us now count, the no of occurances of the sums., that is n(X). Assuming equal probability for all 3 outcomes, we could also calculate p(X) alongside n(X). You could count n(X) from above table and cross verify with below table.

In [10]:

from anyflipviz import get_combinations_consolidated

final_df = get_combinations_consolidated(n_outcomes, n_flips)

# JUST TO HIGHLIGHT A COLUMN
# thank you: https://stackoverflow.com/questions/41654949/pandas-style-function-to-hignlight-specific-columns
coldict = {'n(x)':'yellow'}
def highlight_cols(s, coldict):
    if s.name in coldict.keys():
        return ['background-color: {}'.format(coldict[s.name])] * len(s)
    return [''] * len(s)

final_df.style.apply(highlight_cols, coldict=coldict)

Out[10]:

	x	n(x)	p(x)
0	0	1	0.111111
1	1	2	0.222222
2	2	3	0.333333
3	3	2	0.222222
4	4	1	0.111111

Note that, the highlighted numbers exactly match what Sebastian arrives at. While we recognize and use patterns, it is important to also be able to connect back to this foundational emergence of pattern. While visualizing tree, can help you appreciate the complexity of the problem we have simplified in to patterns, the derivation helps to keep connected to the fundamentals.

Counting Outcomes 7¶

In [11]:

url = 'https://youtu.be/b5gHsdQFZ3k'
YouTubeVideo(strip_url(url))

Out[11]:

In [12]:

# define our problem
n_outcomes = 3  # 0,1,2
n_flips = 3     # as per current problem in above video

g = Digraph(strict=True)
g = draw_graph(g, n_outcomes, n_flips)
g

Out[12]:

Whew, its big. Over to all those possible sequences..

In [13]:

temp_df = get_combinations(n_outcomes, n_flips)
temp_df

Out[13]:

	sequence	x
0	000	0
1	001	1
2	002	2
3	010	1
4	011	2
5	012	3
6	020	2
7	021	3
8	022	4
9	100	1
10	101	2
11	102	3
12	110	2
13	111	3
14	112	4
15	120	3
16	121	4
17	122	5
18	200	2
19	201	3
20	202	4
21	210	3
22	211	4
23	212	5
24	220	4
25	221	5
26	222	6

For just 3 flips, the problem has outgrown in to a complex one, with so many to count..Thanks to our program, now we could easily calculate the no of occurances of all possible sums.

In [14]:

from anyflipviz import get_combinations_consolidated

final_df = get_combinations_consolidated(n_outcomes, n_flips)

final_df.style.apply(highlight_cols, coldict=coldict)

Out[14]:

	x	n(x)	p(x)
0	0	1	0.037037
1	1	3	0.111111
2	2	6	0.222222
3	3	7	0.259259
4	4	6	0.222222
5	5	3	0.111111
6	6	1	0.037037

Whoa! We got it right! :)

Take a moment to compare and wonder how this complicated evolution becomes an easy pattern counting Sebastian deploys, and this could easily be applied to any number of flips without we going through above complicated trees.

Counting Outcomes 8¶

Here we go, for even bigger viz..

In [15]:

url = 'https://youtu.be/zVZJkMwBOwA'
YouTubeVideo(strip_url(url))

Out[15]:

In [16]:

# define our problem
n_outcomes = 3  # 0,1,2
n_flips = 4     # as per current problem in above video

g = Digraph(strict=True)
g = draw_graph(g, n_outcomes, n_flips)
g

Out[16]:

In [17]:

temp_df = get_combinations(n_outcomes, n_flips)
temp_df

Out[17]:

	sequence	x
0	0000	0
1	0001	1
2	0002	2
3	0010	1
4	0011	2
5	0012	3
6	0020	2
7	0021	3
8	0022	4
9	0100	1
10	0101	2
11	0102	3
12	0110	2
13	0111	3
14	0112	4
15	0120	3
16	0121	4
17	0122	5
18	0200	2
19	0201	3
20	0202	4
21	0210	3
22	0211	4
23	0212	5
24	0220	4
25	0221	5
26	0222	6
27	1000	1
28	1001	2
29	1002	3
...	...	...
51	1220	5
52	1221	6
53	1222	7
54	2000	2
55	2001	3
56	2002	4
57	2010	3
58	2011	4
59	2012	5
60	2020	4
61	2021	5
62	2022	6
63	2100	3
64	2101	4
65	2102	5
66	2110	4
67	2111	5
68	2112	6
69	2120	5
70	2121	6
71	2122	7
72	2200	4
73	2201	5
74	2202	6
75	2210	5
76	2211	6
77	2212	7
78	2220	6
79	2221	7
80	2222	8

81 rows 2 columns

In [18]:

final_df = get_combinations_consolidated(n_outcomes, n_flips)

final_df.style.apply(highlight_cols, coldict=coldict)

Out[18]:

	x	n(x)	p(x)
0	0	1	0.0123457
1	1	4	0.0493827
2	2	10	0.123457
3	3	16	0.197531
4	4	19	0.234568
5	5	16	0.197531
6	6	10	0.123457
7	7	4	0.0493827
8	8	1	0.0123457

Central Limit Theorem¶

In [19]:

url = 'https://youtu.be/RAGZjOOc7o8'
YouTubeVideo(strip_url(url))

Out[19]:

There is no question here, I just added, for proper conclusion of the pattern we observed so far. Let us draw as well for n_flips = 4, just to see, how the graph looks. What is to be fathomed is, why the sequences have this property? It has nothing to do with probability (which again as a density function that would happen just as a linear function of this distribution as shown on RHS ) so may be we should dig further, why this phenomenon occurs. When you encounter probability questions, and one says assume guassian distribution, the key to why so, lies in understanding this distribution we observe.

In [22]:

from anyflipviz import plot_combinations_consolidated

plot_combinations_consolidated(final_df, fontsize=12)

LHS is the graph, Sebastian talks about in above video.